Un tutorial sui display a 7 segmenti di Simone Salvan, allievo del prof Marco Gottardo.
Display a
7 segmenti
Micro-GT con PIC16F877A
Terza
lezione
Mi chiamo Simone Salvan e mi occupo di
manutenzione di apparati elettromedicali installati presso vari ospedali del
triveneto. Molti apparati ospedalieri sono controllati da PLC, per cui ho
deciso di iscrivermi a uno dei corsi serali che si svolgono in una piccola
scuola di Padova. Il centro culturale ZIP (zona industriale di Padova). A
questo corso ho conosciuto il prof. Marco Gottardo, utente di grix, noto come ad.noctis. Tra le
proposte formative, Gottardo mi fa notare anche un corso di microcontrollori
PIC, a cui ho aderito con entusiasmo dato che molti
dei dispositivi ospedalieri funzionano anche con
questi dispositivi.
In questo articolo vorrei
condividere le mie esperienze e i miei progressi nel mondo dei PIC.
Simone.
Accensione del Display a sette segmenti.
La frequenza al corso di PIC prevede, benché' non sia obbligatorio, di dotarsi
di materiale didattico consigliato. Questo è:
La lezione a cui mi riferisco
è la terza, ed essendo lezioni di 3 ore ciascuna abbiamo fatto solo 9 ore,
tuttavia ho già acceso il display apprendendo la teoria del codice BCD, la
conversione hardware in modalità sette segmenti, l'installazione e la
compilazione con MPLAB e i rudimenti del C.
Nozioni di base.
Per usare il display a bordo della scheda di sviluppo bisogna decidere a priori
alcune cose:
Noi useremo il display a catodo comune, con i catodi intercettati prima della massa da dei transistor BC337,
e quindi quattro segnali saranno generati dal PIC solo per abilitare
l'accensione del display.
Le sette linee, che corrispondono ai sette segmenti
dei display non sono generate dal PIC direttamente, ma
da un circuito integrato pilotato da esso. Una specie di decoder che prende 4 linee di uscita del processore e le converte nelle sette
linee necessarie e correttamente configurate.
Ci viene spiegato che il
codice BCD è una sorta di sottoinsieme del codice binario ridotto ai soli primi
4 bit, solitamente indicati con b3,b2,b1,b0
posti come intestazione delle colonne di una tabella. Dato che i possibili
stati di una variabile binaria sono 2 (0 oppure 1) e che le variabili in esame
sono 4, le possibili combinazione di queste sono
"possibili stati elevato al numero delle variabili" quindi in totale
sono 16.
Dato che la numerazione parte da zero, il massimo
valore esprimibile è il 15.
Infatti 23+22+21+20=15
Subito si capisce che ci sono più combinazioni di
quelle che ci servono dato che su una singola cifra
LED, chiamata DIGIT, posso rappresentare i numeri da 0 a 9.
Per costruire il codice BCD facciamo così:
Scriviamo le intestazioni delle colonne come detto
sopra, ovvero la sequenza "b3 b2
b1 b0".
Consideriamo la colonna più a destra, e scendiamo in
verticale, per 16 posizioni, alternando 0 e 1 a
partire da zero.
Si ottiene:
b3 |
b2 |
b1 |
b0 |
0 |
|||
1 |
|||
0 |
|||
1 |
|||
0 |
|||
1 |
|||
0 |
|||
1 |
|||
0 |
|||
1 |
|||
0 |
|||
1 |
|||
0 |
|||
1 |
|||
0 |
|||
1 |
La prima colonna a destra ha quindi una periodicità di
riga pari a 1.
Le colonne successive, spostandosi verso sinistra, si
costruiscono abbinando la periodicità 2 - 4 - 8 che corrisponde a cambiare
stato ogni 2 righe, ogni 4 righe e ogni 8 righe, fermo
restando che la prima riga sara' sempre costituita da
zeri. quindi si
avrà:
Per la periodicità
"2" il cambio di stato ogni due righe nella colonna di b1.
b3 |
b2 |
b1 |
b0 |
0 |
|||
0 |
|||
1 |
|||
1 |
|||
0 |
|||
0 |
|||
1 |
|||
1 |
|||
0 |
|||
0 |
|||
1 |
|||
1 |
|||
0 |
|||
0 |
|||
1 |
|||
1 |
Per la periodicità
"4" il cambio di stato ogni quattro righe nella colonna di b2.
b3 |
b2 |
b1 |
b0 |
0 |
|||
0 |
|||
0 |
|||
0 |
|||
1 |
|||
1 |
|||
1 |
|||
1 |
|||
0 |
|||
0 |
|||
0 |
|||
0 |
|||
1 |
|||
1 |
|||
1 |
|||
1 |
Per la periodicità
"8" il cambio di stato ogni otto righe nella colonna di b3.
b3 |
b2 |
b1 |
b0 |
0 |
|||
0 |
|||
0 |
|||
0 |
|||
0 |
|||
0 |
|||
0 |
|||
0 |
|||
1 |
|||
1 |
|||
1 |
|||
1 |
|||
1 |
|||
1 |
|||
1 |
|||
1 |
La matrice completa, in cui si rappresentano tutte le
colonne, è anche detto codice BCD, oppure codice 8421 ridotto alle prime 10 combinazioni.
b3 |
b2 |
b1 |
b0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
0 |
0 |
1 |
0 |
0 |
0 |
1 |
1 |
0 |
1 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
1 |
1 |
0 |
0 |
1 |
1 |
1 |
1 |
0 |
0 |
0 |
1 |
0 |
0 |
1 |
1 |
0 |
1 |
0 |
1 |
0 |
1 |
1 |
1 |
1 |
0 |
0 |
1 |
1 |
0 |
1 |
1 |
1 |
1 |
0 |
1 |
1 |
1 |
1 |
La sopra riportata è l'input
atteso dal circuito integrato CD4511, ovvero il decoder BCD -> sette
segmenti.
Lo schema di principio, fatto ad
una velocità sorprendente dall'insegnante usando il paint,
e proiettato sul muro della classe, è il sottostante. Le spiegazioni sono state
fatte in tempo reale durante il disegno, che alla fine ci è stato fornito in
formato bmp. Questo è stato allegato ai nostri
appunti, in realtà poco diversi dall'articolo che state leggendo.
In linea di principio l'esercizio richiede la
visualizzazione di un numero a due cifre sul display presente sulla Micro-GT
versatile IDE.
Dato che questo programmer/demoboard dispone di 4 digit, abbiamo optato di allinearci a destra tenendo spente
le rimanenti cifre.
La richiesta è quella di fare
comparire il numero 12 sui due digit di destra, come
mostrato nello schema di principio sovrastante.
Sembra semplice, ma in realtà dobbiamo capire alcuni
concetti.
Osservando il Bus (insieme di linee parallele indicate
con a,b,c,d,e,f,g,
che corrispondono ai led dei segmenti del display), ci accorgiamo che vi
transita sia la cifra 1 che la cifra 2, quindi queste non possono coesistere
temporalmente parlando.
A gestire il traffico sul bus ci pensa il microcontroller, ma a consentire l'accensione dei display
ci pensano i due transistor BC337 che lavorando in saturazione/interdizione
sono in pratica degli interruttori controllati dai segnali presenti su
ulteriori due linee del Microcontroller.
In definitiva, il PORTB è diviso in due, la parte
bassa in cui è presente il numero BCD da inviare al decoder CD4511 e la parte
alta che invece multiplexa il bus, consentendo ad un solo Display alla volta di visualizzare ciò che sta
transitando sul bus.
I display utilizzati sono dei
catodo comune del modello in foto:
Al suo interno vi
sono sette, (più uno che accenderà il punto decimale), LED, collegati in questo
modo:
Al pin numero 3 del display viene collegato il collettore del transistor
BC337, che satura con soli 2mA.
Un rapido studio
della maglia di base, alimentata a +Vdd = 5V permette il calcolo della resistenza RB che risulta pari
a 2k2.
Grossomodo il calcolo
della maglia è:
Ib*Rb+Vbe-Vdd=0 risolvendo questa equazione rispetto a Rb si ottiene Rb= (Vdd-Vbe)/Ib
Sostituendo i valori,
Vdd=5, Vbe=0,6 Ib=2mA si ottiene 2k2 ohm [(rosso,
rosso,rosso, oro) 1/4W]
Schema reale del programmer demoboard.
La Micro-GT versatile IDE possiede una quantità molto
elevata di dipswitch, strip line, punti di
connessione, ecc.
Dobbiamo quindi vedere lo schema per
poter definire dove e come inviare i segnali tramite il firmware che
stiamo per sviluppare.
Decidiamo di non
usare il bus collegato internamente al fine di rendere compatibile il firmware
che sviluppiamo anche per chi non possiede questo programmer,
quindi tutte le linee del dipswitch S26, vanno
aperte. Questo scollega completamente questa sezione della scheda dal micro
dando la possibilità di usare la maniera "freeport",
che comporta il collegamento di due cavetti flat a 4 conduttori rispettivamente su:
Al momento non siamo
interessati all'utilizzo dei punti decimali quindi SV21 può rimanere
scollegato.
Nella foto vediamo la
posizione degli stripline maschi SV19 e SV20.
Le serigrafie ci ricordano
la loro funzionalità. Da qui partiremo con dei cavetti piatti, terminati su
strip line femmina in entrambi i lati per innestarci rispettivamente SV19 ->
parte bassa del PORTB, e SV20 ->parte alte del
PORTB.
Rimane quindi da
identificare la posizione del PORTB sulla demoboard.
A tale scopo
visualizziamo il layout componenti.
La fila centrale dei
LED visualizza lo stato del PORTB, quindi si consiglia di abilitarla, almeno in
fase di debug, perchè ci
aiuta a capire se il firmware è corretto e magari la mancata accensione di
qualche segmento è dovuta a un problema hardware o di collegamento dei cavetti flat, oppure dell'efficienza del circuito integrato CD4511,
posto nello zoccolo IC1.
Se, ad esempio,
abbiamo recuperato questo integrato, potrebbe essere bruciato, ma la mancanza
dell'eco LED non ci da questa informazione in maniera
immediata facendoci perdere del tempo prezioso.
Lo schema elettrico
completo della demoboard è scaricabile liberamente
dal sito del prof. Gottardo e vi sarà indispensabile durante lo sviluppo dei
vari software. Il link è -> Demoboard/programmer Micro-GT IDE
Lo sviluppo del
software.
Per lo sviluppo del
software, ci viene imposto lo stile di programmazione
dell'insegnate, che prevede:
Con queste premesse, possiamo dire Il codice si sviluppa
a partire da uno scheletro comune, che si evolverà man
mano che si avanza con le lezioni del corso e che ci permette di risparmiare un
sacco di tempo all'inizio di un nuovo progetto.
Il progetto, come spiegato nel e-book "Micro PIC
partenza immediata", si crea svolgendo i sette passi fondamentali
del wizard integrato in MPLAB.
L'aspetto finale del progetto è questo:
Come prossima vedere si compone di 5
moduli, di cui due ti tipo source, salvati con estensione .C e due ti tipo header salvati con
estensione .h, durante lo sviluppo del codice è sempre
possibile aggiungere altri moduli, o toglierli.
L'aggiunta di un nuovo modulo avviene dal menù "project" di MPLAB alla voce "add
file to project".
Agendo sul quadratino nero con dentro un puntino
rosso, che si trova nella barra degli strumenti di MPLAB, avviene la
compilazione.
Il risultato è questo.
Questa manovra crea
il file ".hex" che
poi sarà riversata nell'area flasch del PIC tramite
la tecnica ICSP, per la quale il sistema di sviluppo dispone di un cavetto
colorato a 5 poli, da porre in questa maniera:
I cavetti rosso
e arancione, che portano dall'ICSP le tensioni di alimentazione
del PIC a 5 v e il riferimento alla massa non sono necessari perché il 16F877A
presente sullo zoccolo textool risulta già internamente
collegato tramite le piste della scheda. La tensione Vpp=13,2V,
sul filo marrone, è generata dal regolatore IC5, che vediamo in basso a
sinistra sopra al connettore X1. Questo è sul regolatore a 12V
quindi la tensione viene alzata di 1,2V grazie alla presenza dei due diodi D3 e
D2, in serie, presenti al pin centrale del 7812 e con il catodo verso massa.
Se il trasferimento,
che a scuola usualmente facciamo usando il programma PICPROG2009, non dovesse
andare a buon fine, oppure il software non riconosce la scheda, potrebbe essere
necessario aprire momentaneamente i jumper JP8 e JP9, che fermano il quarzo XTAL 2.
Alcuni degli
esemplari di Micro-GT che abbiamo in laboratorio funzionano tramite la tecnica
LVP, low voltage programming, che richiede il precaricamento
di un firmware chiamato bootloader. Questo si mette
in ascolto sulla porta seriale nei primi 200 millisecondi dopo l'accensione e
se trova un flusso, creato da un programma istallato nel PC nella seriale,
converte l'azione del PIC da esecuzione a programmazione.
Il trasferimento è
davvero molto rapido.
Le schede che
funzionano in questa maniera sono prive dell'integrato IC4, il CD4069, che
basta rimuovere dallo zoccolo. Il consenso al caricamento avviene premendo il
pulsante di reset mentre il programma "pic downloader" è in "searcing
for bootloader", ovvero
ha già preso il file .hex e lo sta proponendo alla
porta seriale.
scarica bootloader per 16F877A
20MHz 38400bps
Approfondimenti in
merito alla programmazione LVP con bootloader sono
sul libro "Let's GO PIC!!!
the book" a cui è dedicato un intero capitolo.
Scaricate da qua il
programma completo e provate a compilare: ->download
esercizio due digit
A questo punto
dovreste essere in grado di compilare un programma con MPLAB, ma nel caso ci
fossero problemi guardate il capitolo 1 del corso Let's GO PIC, che vi guida passo passo,
o se avete il libro, guardate l'apposito capitolo.
Comunque non
dimenticate di selezionare il compilatore HITEC per il quale ho
sviluppato questo esercizio.
Il digramma di flusso
ci aiuta notevolmente nella fase di sviluppo software. I flowchart
sono direttamente applicabili solo quando il programma
è suddiviso in parti sufficientemente piccole, ecco perché' l'insegnate ci fa
dividere il tutto in una quantità elevata di piccole funzioni.
Vediamo il software
nel dettaglio.
Mostriamo per prima
il modulo che contiene il main. Questo è salvato con nome duedigit.c
/**************************************************
* programma multiplexaggio su 2
display *
* firmware version:1.0 *
* autore: Simone Salvan *
* data:15/01/2013 *
* interfaccia CD4511 *
* MCU: 16F877A *
* Piattaforma hardware: Micro-GT IDE *
* Piattaforma software: MPLAB v8.60 *
* linee: A->RB0 *
* B->RB1 *
* C->RB2
*
* D->RB3
*
************************************************/
#define _LEGACY_HEADERS //
permette di riconoscere i fuse ai nuovi compilatori
#include <pic.h>
#include "delay.h"
#include "settaggi.h"
__CONFIG (HS & WDTEN & PWRTDIS & BORDIS & LVPDIS &
DUNPROT & WRTEN &
DEBUGDIS & UNPROTECT); //impostazione dei fuse, abilitiamo solo il timer watchdog
#define A RB0
#define B RB1
#define C RB2
#define D RB3
#define display1 RB7
#define display2 RB6
void settaggi(); //predichiarazione di una funzione esterna (si trova nel
modulo settaggi.h
void main(){
settaggi();
int conta;
conta=2;
while(1){
PORTB=conta;
display1=1;
display2=0;
DelayMs(10);
conta=conta-1;
PORTB=conta;
display1=0;
display2=1;
DelayMs(10);
conta=2;
CLRWDT(); //resetta il watch
dog timer, se ci dimentichiamo il programma si blocca
}
}
----------------------------------------------------------------------------
Vediamo il contenuto del file settaggi.h
void settaggi(){
TRISB=0b00000000;
PORTB=0;
}
--------------------------------------------------------------------------.
Questo piccolo programma, sembra banale, ma in realta', ci viene spiegato, e la
base da cui partiremo per sviluppare un orologio digitale da visualizzare sui 4
digit integrati sulla scheda di sviluppo Micro-GT.
La tecnica di controllo in multiplexing dei digit non e'
sufficiente per fare l'orologio, perche' dovremmo
prima imparare a generare la base tempi stabile e sufficientemente precisa.
Questa verra'
creata agendo su quella parte hardware interna del PIC chiamata TMR0 e
necessita della conoscenza della gestione dei segnali di interrupt, piuttosto
prematuri per una terza lezione a cui siamo giunti.
Il prossimo step sara' quello di prendere il
controllo della cifra visualizzata, attualmente il numero 12, con due pulsanti,
scelti tra quelli integrati nella demoboard. Lo scopo
e' quello di avvicinarsi al
concetto di preset dell'ora visualizzata, quindi la
regolazione aumentando manualmente le ore o i minuti.
La piccola scuola dispone di
molte postazioni Micro-GT, tuttavia gli allievi preferiscono aquistare il proprio esemplare per potersi esercitare a
casa. Nella foto vediamo la mia scheda di sviluppo, la Micro-GT IDE assemblata
in versione ridotta, inserita in una scatola assieme ad un alimentatore
recuperato da un vecchio apparato ospedaliero. Nella foto non è ancora visibile
ma ora c'è un plexyglass che impedisce di toccare le
parti sotto tensione di rete. Cosa da non trascurare per la sicurezza
elettrica.
Questa foto mostra la presenza del cavetto ICSP infatti in questo momento la scheda è in programmazione.
Sullo zoccolo textool il
mitico 16F877A, tuttavia, si potrebbe sostituire con un più performante
18F4550, ma poco adatto a chi fa i primi passi perchè
concettualmente più complesso. In realtà, nel textool
possiamo mettere tantissimi microcontrollori, benchè
a scuola ci insegnino solo 16F876A, 16F877A, e cenni ai quasi equivalenti pin
to pin 18F2550 e 18F4550.
I due processori della serie 18F sono molto
interessanti perchè rendono la scheda controllabile
via USB, senza modifiche hardware, a parte qualche accorgimento sui bus. Le
routine software sono standard, liberamente utilizzabili, ma
aimè un pò complesse per chi comincia.
La scatola di derivazione, funge da valigetta e mi è molto comoda per il
trasporto. Ora, la scheda che vediamo sopra, è stata completata con i display
che ho pensato di montare su uno zoccolo a 40 pin per
renderli estraibili e quindi poterli usare anche nei vari minishield
per fare esperimenti diversi. Possiedo anche un secondo esemplare, assemblato in maniera completa, che vediamo nella prossima
foto.
Tuttavia, è possibile
montare solo le sezioni che interessano ammortizzando notevolmente la spesa o
spalmandola nei tempi necessari all'apprendimento, ad esempio se il motore
passo passo lo sviluppiamo tra 2
mesi, potremmo non montare il chip L298, e tutto l' hardware che lo circonda.
Insomma possiamo aspettare il prossimo stipendio prima di fare altri acquisti
di componenti.
Dato che lo stampato
costa solo 15€ è possibile, partire a costo ridottissimo. Ad esempio, se
volessimo fare solo le prime prove con I/O digitale si
potrebbe assemblare come nella prossima foto:
Anche lo zoccolo textool potrebbe essere opzionale se decidiamo si
specializzarci solo in quei PIC a 40 pim che possono essere alloggiati in un normale zoccolo, ad
esempio il 16F877A oppure il 18F4550, e molti altri.
Assemblata la scheda in
questa maniera è possibile dimezzare il costo del sistema di sviluppo, ma in
certe condizioni, e studiando gli schemi elettrici è possibile risparmiare
ulteriormente.
Queste condizioni
particolari di utilizzo, ci vengono segnalate dallo
stesso insegnate, che ha disegnato la scheda.
Ad esempio, se disponiamo di un dispositivo di programmazione prodotto
dalla Microchip, è possibile rendere compatibile la Micro-GT IDE direttamente
con MPLAB. questi è il pickit3, oppure la versione precedente PICKIT2.
In queste condizioni
è possibile non assemblare IC4 e IC2, i tre led DVPP,
DPGC, DPGD, i transistor Q6 e Q7 e tutte le resistenze che hanno a che fare con
questa area programmer.
A questo punto
possiamo entrare in scheda come si vede in questa foto, che ho copiato dal
libro "Let's GO PIC the book".
In questo caso, dopo
avere compilato il programma, non sarà necessario andare a cercare il file .hex che è stato generato, ma
semplicemente andare su "programmer" nella
barra degli strumenti di MPLAB, selezionare PICKIT3, e dare il comando di
scrittura. Il tutta tramite la porta USB dei notebook.
Il cavetto da
costruire è questo in cui si raccomanda di rispettare i colori.
La parte a sinistra, i maschi, si infilano
direttamente nel PICKIT3, mentre i terminali femmina di destra si infilano
negli strip della scheda.
In questa maniera:
anche questa foto la
ho copiata dal libro con il permesso dell'insegnante.
L'insegnate
consiglia di assemblare comunque la porta seriale perchè
sarà oggetto di molte prove che si fanno a lezione, infatti è previsto lo
studio di sistemi di interfacciamento a PC, con programmi eseguiti in visual basic 6 o in visual studio .net per fare delle "supervisioni"
o una specie di sistemini "SCADA" che useranno
l'RS232.
Vediamo un filmato di
test di accensione del display, e'
una specie di demo per vedere se il bus e' settato
giusto e se l'hardware e' operativo
Bibliografia: Micro PIC
partenza immediata ebook dicembre 2012 disponibile su www.lulu.com
Let's GO PIC!!!
the book settembre 2012 disponibile su www.lulu.com
Appunti dalle lezioni
serali del centro culturale ZIP di Padova
Note: Questo articolo
e' stato tratto dalle
lezione di Microcontrollori PIC di martedi' 15
gennaio 2013. L'insegnate mi ha concesso
l'autorizzazione verbale alla divulgazione.
This opera is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike
2.5 Italy License.